package com.starry.core.utils;

import android.util.Log;

import com.google.gson.Gson;
import com.google.gson.internal.Primitives;
import com.google.gson.stream.JsonReader;

import java.io.Reader;
import java.io.StringReader;
import java.lang.reflect.Type;

public class GsonUtils {

    private final static String TAG = "GsonUtils";
    private static GsonUtils instance;
    private static Gson gson;

    static {
        instance = new GsonUtils();
    }

    private GsonUtils() {
        gson = new Gson();
    }

    public static GsonUtils getGsonInstance() {
        return instance;
    }


    public String toJson(Object object) {
        return gson.toJson(object);
    }

    public <T> T fromJson(String json, Class<T> classOfT) {
        if (json != null && classOfT != null) {
            Object object = fromJson((Reader) (new StringReader(json)), (Type) classOfT);

            try {
                //将转换得到的Object对象包装成与Class对象相对应的基本类型或包装类型，并返回。
                // 如果转换失败，则捕获异常并记录日志，然后返回null。
                return Primitives.wrap(classOfT).cast(object);
            } catch (Throwable var4) {
                Log.e(TAG, "fail fromJson cast=" + var4);
                return null;
            }
        } else {
            return null;
        }
    }

    private <T> T fromJson(Reader json, Type typeOfT) {
        if (json != null && typeOfT != null) {
            try {
                //使用JsonReader将Reader对象封装，
                //并使用GSON对象进行反序列化，然后返回结果
                //这里使用了JsonReader，它才是用于反序列化的主角，Gson只是一个门面，真正干实事的是JsonReader
                JsonReader jsonReader = new JsonReader(json);
                return gson.fromJson(jsonReader, typeOfT);
            } catch (Throwable var3) {
                Log.e(TAG, "fail fromJson reader" + var3);
                return null;
            }
        } else {
            return null;
        }
    }
}
